<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>

</body>
<script>

    //  for (var i in list) { // 遍历数组
    //     console.log(i, list[i]); // 每次循环时执行的代码(循环下标,循环的当前元素)
    // }


    // 数组的遍历方法 => 数组的拓展方法(官方封装的专门供数组使用的方法)
    // 语法: 数组.方法名()

    // forEach map  filter some every find(ES6) findIndex(ES6) reduce reduceRight 



    // forEach()  数组遍历
    // 作用: 遍历数组,每次循环时执行传入的函数(回调函数),
    // 回调函数 => 有三个形式参数(参数可以自己改),  item:循环当前元素, index:循环的当前下标, array: 原数组(被遍历的数组 -> 很少用
    // 返回值: undefined  (forEach内部没有设置返回值 => 默认返回undefind)


    // var list = [1, 4, 7, 8, 5, 2, 3, 6, 9];
    // // 遍历数组
    // list.forEach(function(item,index,array){ // 形参(item:循环当前元素, index:循环的当前下标, array: 原数组(被遍历的数组 -> 很少用))
    //     console.log(item,index,array); //  每次循环时执行的代码
    // });


    // var list = [1, 4, 7, 8, 5, 2, 3, 6, 9];
    // var sum = 0;
    // // 遍历数组
    // list.forEach(function(item){ // 形参(item:循环当前元素, index:循环的当前下标, array: 原数组(被遍历的数组 -> 很少用))
    //     console.log(item); //  每次循环时执行的代码
    //     sum += item;
    // });
    // console.log(sum);


    // map()   数组映射(根据原数组得到新数组)
    // 作用: 遍历数组,每次循环时执行传入的函数(回调函数),接收每次函数执行的结果(返回值),放到新数组中,并返回该新数组
    // 回调函数 => 有三个形式参数(参数可以自己改),  item:循环当前元素, index:循环的当前下标, array: 原数组(被遍历的数组 -> 很少用)
    // 返回值:新数组

    // var list = [1, 4, 7, 8, 5, 2, 3, 6, 9];
    // // 遍历数组
    // var result = list.map(function(item,index,array){ // 形参(item:循环当前元素, index:循环的当前下标, array: 原数组(被遍历的数组 -> 很少用))
    //     console.log(item,index,array); //  每次循环时执行的代码
    //     return item * 10;
    // });
    // console.log(result);
    // console.log(list);

    // 等价于
    // var list = [1, 4, 7, 8, 5, 2, 3, 6, 9];
    // var fn = function(item,index,array){ // 形参(item:循环当前元素, index:循环的当前下标, array: 原数组(被遍历的数组 -> 很少用))
    //     console.log(item,index,array); //  每次循环时执行的代码
    //     return item * 10;
    // }
    // var arr = [];
    // for(var i in list){
    //     var result = fn(list[i],Number(i),list);
    //     arr.push(result);
    // }
    // console.log(arr);

    // filter()  数组过滤/筛选(筛选除所有满足条件的元素)
    // 作用: 遍历数组,每次循环时执行传入的函数(回调函数),函数的返回值一般是一个条件表达式(筛选条件),把满足条件的元素放到新数组(如果返回值非布尔值,会先隐式转化为布尔值,在判断)
    // 回调函数 => 有三个形式参数(参数可以自己改),  item:循环当前元素, index:循环的当前下标, array: 原数组(被遍历的数组 -> 很少用)
    // 返回值:新数组

    //  var list = [1, 4, 7, 8, 5, 2, 3, 6, 9];
    // // 遍历数组
    // var result = list.filter(function(item,index,array){ // 形参(item:循环当前元素, index:循环的当前下标, array: 原数组(被遍历的数组 -> 很少用))
    //     console.log(item,index,array); //  每次循环时执行的代码
    //     // return item % 2 == 0; // 条件表达式(true(偶数) / false(奇数))
    //     // return item % 2 == 0 && item % 3 == 0; // 条件表达式(true(6的倍数) / false(非6的倍数))
    //     return item % 2 ; // 返回值非布尔值 (0(false)  1(true))  => 
    // });
    // console.log(result);


    // find()  数组查找(查找满足条件的元素的第一个元素)
    // 作用: 遍历数组,每次循环时执行传入的函数(回调函数),函数的返回值一般是一个条件表达式(筛选条件),返回满足条件的第一个元素(如果返回值非布尔值,会先隐式转化为布尔值,在判断)
    // 回调函数 => 有三个形式参数(参数可以自己改),  item:循环当前元素, index:循环的当前下标, array: 原数组(被遍历的数组 -> 很少用)
    // 返回值: 存在就返回第一个满足条件的元素 不存在: undefined

    // findIndex()  数组查找(查找满足条件的元素的第一个元素的下标)
    // 返回值: 存在就返回第一个满足条件的元素的下标 不存在: -1

    /*     var list = [1, 4, 7, 8, 5, 2, 3, 6, 9];
      // 遍历数组
      var result = list.find(function(item,index,array){ // 形参(item:循环当前元素, index:循环的当前下标, array: 原数组(被遍历的数组 -> 很少用))
          console.log(item,index,array); //  每次循环时执行的代码
          // return item % 4 == 0;  // 找4的倍数
          // return item % 3 == 0;  // 找3的倍数
          return item % 3 == 0 && item % 4 == 0;  // 找3 4的倍数
      });
      console.log(result); */


    // var list = [1, 4, 7, 8, 5, 2, 3, 6, 9];
    // // 遍历数组
    // var result = list.findIndex(function (item, index, array) { // 形参(item:循环当前元素, index:循环的当前下标, array: 原数组(被遍历的数组 -> 很少用))
    //     console.log(item, index, array); //  每次循环时执行的代码
    //     // return item % 4 == 0;  // 找4的倍数
    //     return item % 3 == 0;  // 找3的倍数
    //     // return item % 3 == 0 && item % 4 == 0;  // 找3 4的倍数
    // });
    // console.log(result);

    // some()    判断是否存在满足条件的元素(本质: 假设法, 假设没有,找到一个就是由)
    // 作用: 遍历数组,每次循环时执行传入的函数(回调函数),函数的返回值一般是一个条件表达式(判断条件),只要有一个元素满足条件就返回true,都不返回返回false(如果返回值非布尔值,会先隐式转化为布尔值,在判断)
    // 回调函数 => 有三个形式参数(参数可以自己改),  item:循环当前元素, index:循环的当前下标, array: 原数组(被遍历的数组 -> 很少用)
    // 返回值: 只要有一个元素满足条件就返回true,都不返回返回false


   var list = [1, 4, 7, 8, 5, 2, 3, 6, 9];
    // 遍历数组
    var result = list.some(function (item, index, array) { // 形参(item:循环当前元素, index:循环的当前下标, array: 原数组(被遍历的数组 -> 很少用))
        console.log(item, index, array); //  每次循环时执行的代码
        // return  item % 3 == 0;  // 找3的倍数
        return  item % 3 == 0 && item % 4 == 0;  // 找3 4的倍数
    });
    console.log(result);


    // every() 判断数组中的元素是否都满足条件(本质:假设法 假设都满足(true),有一个不满足就返回false)
    // 作用: 遍历数组,每次循环时执行传入的函数(回调函数),函数的返回值一般是一个条件表达式(判断条件),只要有一个元素不满足条件就返回false,都满足返回true(如果返回值非布尔值,会先隐式转化为布尔值,在判断)
    // 回调函数 => 有三个形式参数(参数可以自己改),  item:循环当前元素, index:循环的当前下标, array: 原数组(被遍历的数组 -> 很少用)
    // 返回值:只要有一个元素不满足条件就返回false,都满足返回tru

    var list = [1, 4, 7, 8, 5, 2, 3, 6, 9];
    var result = list.every(function (item, index, array) { // 形参(item:循环当前元素, index:循环的当前下标, array: 原数组(被遍历的数组 -> 很少用))
        console.log(item, index, array); //  每次循环时执行的代码
        // return true;

        // return item % 2 == 0;  //都是偶数
        // return item % 2 == 1;  //都是奇数
        return item > 0;
    });
    console.log(result);




</script>

</html>